/**
 * 数学工具类
 * 包含游戏中使用的各种数学功能，如伪随机数生成等
 */
export class MathUtils {
    /**
     * 基于种子生成伪随机数
     * 使用线性同余法(LCG)实现一个简单的伪随机数生成器
     * @param seed 随机数种子
     * @returns 0到1之间的随机数
     */
    public static pseudoRandom(seed: number): number {
        // 线性同余法参数 (来自数值算法标准)
        const a = 1664525;
        const c = 1013904223;
        const m = Math.pow(2, 32);
        
        // 计算新的种子值
        const newSeed = (a * seed + c) % m;
        
        // 转换为0-1之间的值
        return newSeed / m;
    }
    
    /**
     * 生成一个指定范围内的随机整数
     * @param min 最小值（包含）
     * @param max 最大值（包含）
     * @param seed 可选的随机数种子
     * @returns 指定范围内的随机整数
     */
    public static randomInt(min: number, max: number, seed?: number): number {
        let random: number;
        
        if (seed !== undefined) {
            // 使用伪随机数生成器
            random = this.pseudoRandom(seed);
        } else {
            // 使用标准随机数
            random = Math.random();
        }
        
        // 计算范围内的随机整数
        return Math.floor(random * (max - min + 1)) + min;
    }
    
    /**
     * 生成一个指定范围内的随机浮点数
     * @param min 最小值（包含）
     * @param max 最大值（包含）
     * @param seed 可选的随机数种子
     * @returns 指定范围内的随机浮点数
     */
    public static randomFloat(min: number, max: number, seed?: number): number {
        let random: number;
        
        if (seed !== undefined) {
            // 使用伪随机数生成器
            random = this.pseudoRandom(seed);
        } else {
            // 使用标准随机数
            random = Math.random();
        }
        
        // 计算范围内的随机浮点数
        return random * (max - min) + min;
    }
    
    /**
     * 限制一个值在指定范围内
     * @param value 要限制的值
     * @param min 最小值
     * @param max 最大值
     * @returns 限制后的值
     */
    public static clamp(value: number, min: number, max: number): number {
        return Math.max(min, Math.min(max, value));
    }
    
    /**
     * 计算两点之间的距离
     * @param x1 第一点的x坐标
     * @param y1 第一点的y坐标
     * @param x2 第二点的x坐标
     * @param y2 第二点的y坐标
     * @returns 两点之间的距离
     */
    public static distance(x1: number, y1: number, x2: number, y2: number): number {
        const dx = x2 - x1;
        const dy = y2 - y1;
        return Math.sqrt(dx * dx + dy * dy);
    }
    
    /**
     * 线性插值
     * @param a 起始值
     * @param b 结束值
     * @param t 插值参数(0-1)
     * @returns 插值结果
     */
    public static lerp(a: number, b: number, t: number): number {
        return a + (b - a) * this.clamp(t, 0, 1);
    }
} 